Cosa fa "use strict" in JavaScript e qual è il ragionamento alla base?

Questo articolo sulla modalità Javascript Strict potrebbe interessarti: John Resig - ECMAScript 5 Strict Mode, JSON e altro
Per citare alcune parti interessanti:
Strict Mode è una nuova funzionalità di ECMAScript 5 che consente di collocare un programma o una funzione in un contesto operativo "rigoroso". Questo contesto rigoroso impedisce l'esecuzione di determinate azioni e genera più eccezioni.
E:
La modalità rigorosa aiuta in un paio di modi:
Rileva alcuni errori di programmazione comuni, generando eccezioni.
Previene o genera errori quando vengono intraprese azioni relativamente "non sicure" (come l'accesso all'oggetto globale).
Disabilita le funzionalità confuse o mal pensate.
Nota anche che puoi applicare la "modalità rigorosa" all'intero file ... Oppure puoi usarla solo per una funzione specifica (citando sempre l'articolo di John Resig):
// Codice non rigoroso ...
(funzione(){
"usa rigoroso";
// Definisci rigorosamente la tua libreria ...
}) ();
// Codice non rigoroso ...
Il che potrebbe essere utile se devi mescolare codice vecchio e nuovo ;-)
Quindi, suppongo sia un po 'come "use strict" che puoi usare in Perl (da cui il nome?): Ti aiuta a fare meno errori, rilevando più cose che potrebbero portare a rotture.
La modalità rigorosa è ora supportata da tutti i principali browser.
All'interno dei moduli ECMAScript nativi (con istruzioni di importazione ed esportazione) e nelle classi ES6, la modalità rigorosa è sempre abilitata e non può essere disabilitata.
|
È una nuova funzionalità di ECMAScript 5. John Resig ne ha scritto un bel riassunto.
È solo una stringa che inserisci nei file JavaScript (all'inizio del file o all'interno di una funzione) che assomiglia a questo:
"usa rigoroso";
Inserirlo nel codice ora non dovrebbe causare problemi con i browser attuali poiché è solo una stringa. Potrebbe causare problemi con il codice in futuro se il codice viola il pragma. Ad esempio, se attualmente hai foo = "bar" senza prima definire foo, il tuo codice inizierà a fallire ... che è una buona cosa secondo me.
|
L'istruzione "use strict"; indica al browser di utilizzare la modalità Strict, che è un insieme di funzionalità ridotto e più sicuro di JavaScript.
Elenco delle caratteristiche (non esaustivo)
Non consente le variabili globali. (Cattura le dichiarazioni var mancanti e gli errori di battitura nei nomi delle variabili)
Assegnazioni con errori silenziosi genereranno errori in modalità rigorosa (assegnando NaN = 5;)
I tentativi di eliminare proprietà non cancellabili verranno lanciati (elimina Object.prototype)
Richiede che tutti i nomi di proprietà in un valore letterale oggetto siano univoci (var x = {x1: "1", x1: "2"})
I nomi dei parametri di funzione devono essere univoci (funzione sum (x, x) {...})
Vieta la sintassi ottale (var x = 023; alcuni sviluppatori presumono erroneamente che uno zero precedente non faccia nulla per cambiare il numero.)
Vieta la parola chiave with
eval in modalità rigorosa non introduce nuove variabili
Vieta l'eliminazione di nomi semplici (elimina x;)
Vieta l'associazione o l'assegnazione dei nomi eval e degli argomenti in qualsiasi forma
La modalità rigorosa non alias le proprietà dell'oggetto arguments con i parametri formali. (cioè nella funzione sum (a, b) {return arguments [0] + b;} Questo funziona perché gli argomenti [0] sono legati ad a e così via.)
arguments.callee non è supportato
[Ref: Strict mode, Mozilla Developer Network]
|
Se le persone sono preoccupate per l'utilizzo di use strict, potrebbe valere la pena dare un'occhiata a questo articolo:
Supporto ECMAScript 5 "Strict mode" nei browser. Cosa significa? NovoGeek.com - Il blog di Krishna
Parla del supporto del browser, ma soprattutto di come gestirlo in sicurezza:
function isStrictMode () {
ritorno! questo;
}
/ *
restituisce false, poiché "this" si riferisce all'oggetto globale e
'! this' diventa falso
* /
function isStrictMode () {
"usa rigoroso";
ritorno! questo;
}
/ *
restituisce true, poiché in modalità rigorosa la parola chiave 'questo'
non si riferisce a un oggetto globale, a differenza del JS tradizionale.
Quindi qui, "questo" è "non definito" e "! Questo" diventa vero.
* /
|
Un avvertimento, tutti voi programmatori faticosi: applicare "use strict" al codice esistente può essere pericoloso! Questa cosa non è un adesivo piacevole e felice che puoi schiaffeggiare sul codice per renderlo "migliore". Con il pragma "usa rigoroso", il browser improvvisamente lancia eccezioni in posti casuali che non ha mai lanciato prima solo perché in quel punto stai facendo qualcosa che JavaScript predefinito / sciolto consente felicemente ma JavaScript rigoroso detesta! Potresti avere violazioni della severità nascoste in chiamate usate raramente nel tuo codice che genereranno un'eccezione solo quando alla fine verranno eseguite, ad esempio nell'ambiente di produzione utilizzato dai tuoi clienti paganti!
Se hai intenzione di fare il grande passo, èuna buona idea applicare "usa rigoroso" insieme a test unitari completi e un'attività di compilazione JSHint strettamente configurata che ti darà una certa sicurezza che non ci siano angoli oscuri del tuo modulo che esplodano orribilmente solo perché hai attivato la modalità rigorosa. Oppure, ehi, ecco un'altra opzione: semplicemente non aggiungere "use strict" a nessuno dei tuoi codici legacy, probabilmente è più sicuro in questo modo, onestamente. SICURAMENTE NON aggiungere "use strict" a moduli che non possiedi omantenere, come i moduli di terze parti.
Penso che anche se è un animale mortale in gabbia, "usare rigoroso" può essere una buona cosa, ma devi farlo bene. Il momento migliore per essere rigorosi è quando il tuo progetto è greenfield e inizi da zero. Configura JSHint / JSLint con tutti gli avvisi e le opzioni al massimo quanto la tua squadra può sopportare, ottieni un buon sistema di build / test / asserzione del giorno truccato come Grunt + Karma + Chai, e solo POI inizia a contrassegnare tutti i tuoi nuovi moduli come " usa rigoroso ". Preparati a curare molti errori e avvertimenti fastidiosi. Assicurati che tutti comprendano la gravità configurando la build su FAIL se JSHint / JSLint produce violazioni.
Il mio progetto non era un progetto greenfield quando ho adottato "use strict". Di conseguenza, il mio IDE è pieno di segni rossi perché non ho "use strict" su metà dei miei moduli, e JSHint se ne lamenta. È un promemoria per me su cosa dovrei fare di refactoring in futuro. Il mio obiettivo è essere libero dal contrassegno rosso a causa di tutte le mie dichiarazioni "use strict" mancanti, ma sono passati anni ormai.
|
Utilizzando 'use strict'; improvvisamente non migliora il tuo codice.
La modalità rigorosa JavaScript è una funzionalità di ECMAScript 5. È possibile abilitare la modalità rigorosa dichiarandola all'inizio dello script / funzione.
'usa rigoroso';
Quando un motore JavaScript vede questa direttiva, inizierà a interpretare il codice in una modalità speciale. In questa modalità, vengono rilevati errori quando vengono rilevate alcune pratiche di codifica che potrebbero finire per essere potenziali bug (che è il ragionamento dietro la modalità rigorosa).
Considera questo esempio:
var a = 365;
var b = 030;
Nella loro ossessione di allineare i letterali numerici, lo sviluppatore ha inavvertitamente inizializzato la variabile b con un letterale ottale. La modalità non rigorosa lo interpreterà come un letterale numerico con valore 24 (in base 10). Tuttavia, la modalità rigorosa genererà un errore.
Per un elenco non esaustivo di specialità in modalità rigorosa, vedere questa risposta.
Dove dovrei usare "use strict" ;?
Nella mia nuova applicazione JavaScript: assolutamente! La modalità rigorosa può essere utilizzata come informatore quando stai facendo qualcosa di stupido con il tuo codice.
Nel mio codice JavaScript esistente: Probabilmente no! Se il codice JavaScript esistente contiene istruzioni vietate in modalità rigorosa, l'applicazione si interromperà semplicemente. Se vuoi la modalità rigorosa, dovresti essere pronto a eseguire il debug e correggere il codice esistente. Questo è il motivo per cui usare "use strict"; improvvisamente non migliora il tuo codice.
Come si usa la modalità rigorosa?
Inserisci un 'use strict'; dichiarazione in cima al tuo script:
// File: myscript.js
'usa rigoroso';
var a = 2;
....
Nota che tutto nel file myscript.js verrà interpretato in modalità rigorosa.
Oppure inserisci un 'use strict'; dichiarazione in cima al corpo della funzione:
function doSomething () {
'usa rigoroso';
...
}
Tutto nell'ambito lessicale della funzione doSomething verrà interpretato in modo rigoroso. La parola ambito lessicale è importante qui. Ad esempio, se il codice rigoroso chiama una funzione di una libreria che non è rigorosa, viene eseguito solo il codice in modalità rigorosa e non la funzione chiamata. Vedi questa risposta per una migliore spiegazione.
Quali cose sono proibite in modalità rigorosa?
Ho trovato un bell'articolo che descrive diverse cose che sono proibite in modalità rigorosa (nota che questo non è un elenco esclusivo):
Scopo
Storicamente, JavaScript è stato confuso su come funziona
sono mirati. A volte sembrano essere staticamente limitati, ma alcuni
le caratteristiche li fanno comportare come se fossero dinamicamente definiti. Questo è
confondere, rendendo i programmi difficili da leggere e capire.
L'incomprensione causa bug. È anche un problema per le prestazioni.
Lo scoping statico consentirebbe l'associazione di variabili durante la compilazione
tempo, ma il requisito per l'ambito dinamico significa che l'associazione deve essere
differito al runtime, che viene fornito con prestazioni significative
pena.
La modalità rigorosa richiede che tutte le associazioni di variabili vengano eseguite staticamente.
Ciò significa che le funzionalità che in precedenza richiedevano l'associazione dinamica
deve essere eliminato o modificato. In particolare, l'istruzione with è
eliminata e la capacità della funzione eval di manomettere il
l'ambiente del chiamante è severamente limitato.
Uno dei vantaggi del codice rigoroso è che strumenti come YUI Compressor
può fare un lavoro migliore durante l'elaborazione.
Variabili globali implicite
JavaScript ha variabili globali implicite. Se
non dichiari esplicitamente una variabile, una variabile globale lo è
implicitamente dichiarato per te. Ciò semplifica la programmazione per
principianti perché possono trascurare alcune delle loro pulizie di base
faccende domestiche. Ma rende molto di più la gestione di programmi più grandi
difficile e degrada in modo significativo l'affidabilità. Quindi rigorosamente
modalità, le variabili globali implicite non vengono più create. Dovresti
dichiara esplicitamente tutte le tue variabili.
Perdita globale
Ci sono una serie di situazioni che potrebbero causare questo
per essere vincolato all'oggetto globale. Ad esempio, se ti dimentichi di farlo
fornire il nuovo prefisso quando si chiama un costruttorefunzione, il
costruttore, questo verrà associato inaspettatamente all'oggetto globale, quindi
invece di inizializzare un nuovo oggetto, sarà invece silenzioso
manomissione delle variabili globali. In queste situazioni, la modalità rigorosa lo farà
invece associarlo a undefined, che farà sì che il costruttore a
lancia invece un'eccezione, consentendo di rilevare molto l'errore
prima.
Guasto rumoroso
JavaScript ha sempre avuto proprietà di sola lettura, ma tu
Impossibile crearli da soli fino a quando Object.createProperty di ES5
funzione ha esposto quella capacità. Se hai tentato di assegnare un valore
a una proprietà di sola lettura, fallirebbe silenziosamente. L'assegnazione sarebbe
non modificare il valore della proprietà, ma il programma procederà come
anche se lo aveva fatto. Questo è un rischio per l'integrità che può causare i programmi
andare in uno stato incoerente. In modalità rigorosa, il tentativo di modificare un file
la proprietà di sola lettura genererà un'eccezione.
Octal
La rappresentazione ottale (o base 8) dei numeri era estremamente
utile quando si esegue la programmazione a livello di macchina su macchine la cui parola
le dimensioni erano un multiplo di 3. Avevi bisogno di ottale quando lavoravi con il CDC
Mainframe 6600, che aveva una dimensione della parola di 60 bit. Se potessi leggere
ottale, potresti guardare una parola come 20 cifre. Due cifre rappresentate
il codice operativo e una cifra identificava uno degli 8 registri. Durante
transizione lenta dai codici macchina ai linguaggi di alto livello, è stato
pensato per essere utile per fornire forme ottali nei linguaggi di programmazione.
In C, una rappresentazione estremamente sfortunata dell'ottalità era
selezionato: zero iniziale. Quindi in C, 0100 significa 64, non 100, e 08 è un
errore, non 8. Ancora più purtroppo, questo anacronismo è stato
copiato in quasi tutti i linguaggi moderni, incluso JavaScript, dove
viene utilizzato solo per creare errori. Non ha altro scopo. Quindi dentro
modalità rigorosa, le forme ottali non sono più consentite.
Eccetera
Lo pseudo array degli argomenti diventa un po 'di più
tipo array in ES5. In modalità rigorosa, perde il chiamato e il chiamante
proprietà. Ciò rende possibile passare i tuoi argomenti a untrusted
codice senza rinunciare a molto contesto confidenziale. Anche il
la proprietà degli argomenti delle funzioni viene eliminata.
In modalità rigorosa, le chiavi duplicate in un valore letterale di funzione produrranno un file
Errore di sintassi. Una funzione non può avere due parametri con lo stesso nome.
Una funzione non può avere una variabile con lo stesso nome di una delle sue
parametri. Una funzione non può eliminare le proprie variabili. Un tentativo di
eliminare una proprietà non configurabile ora genera un'eccezione. Primitivo
i valori non vengono inseriti in modo implicito.
Parole riservate per future versioni di JavaScript
ECMAScript 5 aggiunge un elenco di parole riservate. Se li usi come variabili o argomenti, la modalità rigorosa genererà un errore. Le parole riservate sono:
implementa, interface, let, package, private, protected, public, static e yield
Ulteriori letture
Modalità rigorosa - JavaScript | MDN
Supporto del browser per la modalità rigorosa
Passaggio alla modalità rigorosa
|
Consiglio vivamente a ogni sviluppatore di iniziare a utilizzare la modalità rigorosa ora. Ci sono abbastanza browser che lo supportano che la modalità rigorosa ci aiuterà legittimamente a salvarci da errori che non sapevamo nemmeno fossero nel tuo codice.
Apparentemente, nella fase iniziale ci saranno errori che non abbiamo mai riscontrato prima. Per ottenere il massimo vantaggio, dobbiamo eseguire test adeguati dopo essere passati alla modalità rigorosa per assicurarci di aver catturato tutto. Sicuramente non ci limitiamo a utilizzare rigorosamente il nostro codice e presumiamo che non ci siano errori. Quindi il problema è che è ora di iniziare a utilizzare questa funzionalità del linguaggio incredibilmente utile per scrivere codice migliore.
Per esempio,
var person = {
nome: "xyz",
posizione: 'abc',
fullname: function () {"usa rigoroso"; restituisci this.name; }
};
JSLint è un debugger scritto da Douglas Crockford. Incolla semplicemente il tuo script e cercherà rapidamente eventuali problemi ed errori evidenti nel codice.
|
Vorrei offrire una risposta un po 'più fondata che completa le altre risposte. Speravo di modificare la risposta più popolare, ma non è riuscito. Ho cercato di renderlo il più completo e completo possibile.
È possibile fare riferimento alla documentazione di MDN per ulteriori informazioni.
"use strict" una direttiva introdotta in ECMAScript 5.
Le direttive sono simili alle dichiarazioni, ma diverse.
use strict non contiene parole chiave: la direttiva è una semplice espressione di espressione, che consiste in una stringa letterale speciale (tra virgolette singole o doppie). I motori JavaScript, che non implementano ECMAScript 5, vedono semplicemente un'istruzione di espressione senza effetti collaterali. Si prevede che le future versioni degli standard ECMAScript introducano l'uso come una vera parola chiave; le virgolette diventerebbero così obsolete.
use strict può essere utilizzato solo all'inizio di uno script o di una funzione, ovvero deve precedere ogni altra istruzione (reale). Non deve essere la prima istruzione in uno script di funzione: può essere preceduta da altre espressioni di istruzioni che consistono in stringhe letterali (e JavaScriptle implementazioni possono trattarli come direttive specifiche per l'implementazione). Le istruzioni letterali stringa, che seguono una prima istruzione reale (in uno script o in una funzione) sono semplici istruzioni di espressione. Gli interpreti non devono interpretarli come direttive e non hanno effetto.
La direttiva use strict indica che il codice seguente (in uno script o una funzione) è un codice rigoroso.
Il codice nel livello più alto di uno script (codice che non è in una funzione) è considerato codice strict quando lo script contiene una direttiva use strict.
Il contenuto di una funzione è considerato codice rigoroso quando la funzione stessa è definita in un codice rigoroso o quando la funzione contiene una direttiva use strict.
Il codice passato a un metodo eval () è considerato codice rigoroso quando eval () è stato chiamato da un codice rigoroso o contiene la stessa direttiva use strict.
La modalità rigorosa di ECMAScript 5 è un sottoinsieme limitato del linguaggio JavaScript, che elimina i deficit rilevanti del linguaggio e offre un controllo degli errori più rigoroso e una maggiore sicurezza. Di seguito sono elencate le differenze tra la modalità rigorosa e la modalità normale (di cui le prime tre sono particolarmente importanti):
Non è possibile utilizzare l'istruzione with in modalità rigorosa.
In modalità rigorosa tutte le variabili devono essere dichiarate: se si assegna un valore a un identificatore che non è stato dichiarato come variabile, funzione, parametro di funzione, parametro della clausola di cattura o proprietà dell'Oggetto globale, verrà visualizzato un ReferenceError. In modalità normale l'identificatore è dichiarato implicitamente come variabile globale (come proprietà dell'Oggetto globale)
In modalità rigorosa la parola chiave this ha il valore undefined nelle funzioni che sono state invocate come funzioni (non come metodi). (In modalità normale, punta sempre all'Oggetto globale). Questa differenza può essere utilizzata per verificare se un'implementazione supporta la modalità rigorosa:
var hasStrictMode = (function () {"use strict"; return this === undefined} ());
Anche quando una funzione viene invocata con call () o apply in modalità rigorosa, questo è esattamente il valore del primo argomento dell'invocazione call () o apply (). (In modalità normale null e undefined vengono sostituiti dall'oggetto globale e i valori, che non sono oggetti, vengono convertiti in oggetti.)
In modalità rigorosa si otterrà un'eccezione TypeError, quando si tenta di assegnare a proprietà di sola lettura o di definire nuove proprietà per un oggetto non estensibile. (In modalità normale entrambi falliscono semplicemente senza messaggio di errore.)
In modalità rigorosa, quando si passa il codice a eval (), non è possibile dichiarare o definire variabili o funzioni nell'ambito del chiamante (come è possibile farlo in modalità normale). Viene invece creato un nuovo ambito per eval () e le variabili e le funzioni sono all'interno di tale ambito. Tale ambito viene eliminato dopo che eval () termina l'esecuzione.
In modalità rigorosa, l'oggetto-argomento di una funzione contiene una copia statica dei valori, che vengono passati a quella funzione. In modalità normale l'oggetto-argomenti ha un comportamento in qualche modo "magico": gli elementi dell'array ei parametri della funzione denominata fanno riferimento ad entrambi lo stesso valore.
In modalità rigorosa si otterrà un SyntaxError quando l'operatore di cancellazione è seguito da un identificatore non qualificato (una variabile, una funzione o un parametro di funzione). In modalità normale, l'espressione di eliminazione non fa nulla e viene valutata come falsa.
In modalità rigorosa riceverai un'eccezione TypeError quando tenterai di eliminare una proprietà non configurabile. (In modalità normale il tentativo semplicemente fallisce e l'espressione di cancellazione viene valutata come falsa).
In modalità rigorosa viene considerato un errore sintattico quando si tenta di definire diverse proprietà con lo stesso nome per un oggetto letterale. (In modalità normale non ci sono errori.)
In modalità rigorosa è considerato un errore sintattico quando una dichiarazione di funzione ha più parametri con lo stesso nome. (In modalità normale non ci sono errori.)
In modalità rigorosa i letterali ottali non sono consentiti (questi sono letterali che iniziano con 0x (in modalità normale alcune implementazioni consentono i letterali ottali).
In modalità rigorosa, gli identificatori eval e gli argomenti vengono trattati come parole chiave. Non è possibile modificare il loro valore, non è possibile assegnare loro un valore e non è possibile utilizzarli come nomi per variabili, funzioni, parametri di funzione o identificatori di un blocco catch.
In modalità rigorosa ci sono più restrizioni sulle possibilità di esaminare lo stack di chiamate. arguments.caller e arguments.callee causano un'eccezione TypeError in una funzione in modalità rigorosa. Inoltre, alcune proprietà del chiamante e degli argomenti delle funzioni in modalità rigorosa causano un'eccezione TypeError quando si tenta di leggerli.
|
I miei due centesimi:
Uno degli obiettivi della modalità rigorosa è consentire un debug più rapido dei problemi. Aiuta gli sviluppatori generando eccezioni quando si verificano determinate cose sbagliate che possono causare un comportamento silenzioso e strano della tua pagina web. Nel momento in cui usiamo rigoroso, il codice restituirà errori che aiutano lo sviluppatore a risolverlo in anticipo.
Poche cose importanti che ho imparato dopo aver usato use strict:
Impedisce la dichiarazione delle variabili globali:
var tree1Data= {name: "Banana Tree", età: 100, leafCount: 100000};
function Tree (typeOfTree) {
var age;
var leafCount;
age = typeOfTree.age;
leafCount = typeOfTree.leafCount;
nameoftree = typeOfTree.name;
};
var tree1 = nuovo albero (tree1Data);
console.log (finestra);
Ora, questo codice crea nameoftree nell'ambito globale a cui è possibile accedere utilizzando window.nameoftree. Quando implementiamo use strict, il codice genera un errore.
Errore di riferimento non rilevato: nameoftree non è definito
Campione
Elimina con affermazione:
with le istruzioni non possono essere minimizzate usando strumenti come uglify-js. Sono inoltre deprecati e rimossi dalle future versioni di JavaScript.
Campione
Previene i duplicati:
Quando abbiamo una proprietà duplicata, viene generata un'eccezione
Uncaught SyntaxError: Proprietà dei dati duplicati nell'oggetto letterale no
consentito in modalità rigorosa
"usa rigoroso";
var tree1Data = {
nome: 'Banana Tree',
età: 100,
leafCount: 100000,
nome: "Banana Tree"
};
Ce ne sono pochi altri, ma ho bisogno di acquisire maggiori conoscenze su questo.
|
Se utilizzi un browser rilasciato nell'ultimo anno circa, molto probabilmente supporta la modalità JavaScript Strict. Solo i browser più vecchi prima che ECMAScript 5 diventasse lo standard attuale non lo supportano.
Le virgolette attorno al comando assicurano che il codice funzioni anche nei browser meno recenti (sebbene le cose che generano un errore di sintassi in modalità rigorosa generalmente causeranno solo il malfunzionamento dello script in modo difficile da rilevare in quei browser meno recenti).
|
Quando si aggiunge "use strict";, i seguenti casi lanceranno un SyntaxError prima che lo script venga eseguito:
Aprendo la strada alle future versioni di ECMAScript, utilizzando una delle nuove parole chiave riservate (in previsione di ECMAScript 6): implements, interface, let, package, private, protected, public, static e yield.
Dichiarazione di funzione in blocchi
if (a : 3: 15)
in : 6: 5
Qui, il compilatore lancia l'errore di riferimento. In modalità rigorosa, il compilatore non ci consente di utilizzare la variabile senza dichiararla. Quindi le perdite di memoria possono essere prevenute. Inoltre, possiamo scrivere codice più ottimizzato.
|
La modalità rigorosa elimina gli errori che sarebbero ignorati in modalità non rigorosa, rendendo così javascript "più sicuro".
È considerato tra le migliori pratiche?
Sì, l'inclusione della modalità Strict è considerata parte delle migliori pratiche quando si lavora con JavaScript. Questo viene fatto aggiungendo la seguente riga di codice nel tuo file JS.
'usa rigoroso';
nel codice.
Cosa significa per i programmi utente?
Indicare che il codice dovrebbe essere interpretato in modalità rigorosa specifica agli interpreti come i browser che dovrebbero trattare il codice letteralmente come scritto e lanciare un errore se il codice non ha senso.
Ad esempio: considera che nel tuo file .js hai il seguente codice:
Scenario 1: [NO STRICT MODE]
var city = "Chicago"
console.log (city) // Stampa il nome della città, ad esempio Chicago
Scenario 2: [NO STRICT MODE]
city ​​= "Chicago"
console.log (city) // Stampa il nome della città, ad esempio Chicago
Allora perché il nome della variabile viene stampato in entrambi i casi?
Senza la modalità rigorosa attivata, i programmi utente spesso eseguono una serie di modifiche al codice problematico nel tentativo di far sì che abbia senso. In superficie, questo può sembrare una bella cosa, e in effetti, lavorare al di fuori della modalità rigorosa consente alle persone di bagnarsi i piedi con il codice JavaScript senza avere tutti i dettagli abbastanza inchiodati. Tuttavia, come sviluppatore, non voglio lasciare un bug nel mio codice, perché so che potrebbe tornare indietro e mordermi in seguito, e voglio anche scrivere un buon codice. Ed è qui che la modalità rigorosa aiuta.
Scenario 3: [MODO RIGOROSO]
'usa rigoroso';
city ​​= "Chicago"
console.log (city) // Errore di riferimento: l'assegnazione è una città variabile non dichiarata.
Suggerimento aggiuntivo: per mantenere la qualità del codice utilizzando la modalità rigorosa, non è necessario scriverlo più e più volte, soprattutto se si dispone di più file .js. Puoi applicare questa regola a livello globale nelle regole eslint come segue:
Nome file: .eslintrc.js
module.exports = {
env: {
es6: vero
},
regole : {
rigoroso: ["errore", "globale"],
},
};
Ok, quindi cosa viene impedito in modalità rigorosa?
L'uso di una variabile senza dichiararla genererà un errore in modalità rigorosa. Questo serve per impedire la creazione involontaria di variabili globali in tutta l'applicazione. L'esempio con la stampa di Chicago copre questo in particolare.
Eliminare una variabile, una funzione o un argomento è un no-no in modalità rigorosa.
"usa rigoroso";
funzione x (p1, p2) {};
elimina x; // Ciò causerà un errore
La duplicazione del nome di un parametro non è consentita in modalità rigorosa.
"usa rigoroso";
funzione x (p1, p1) {}; // Ciò causerà un errore
Le parole riservate nel linguaggio Javascript non sono consentite in modalità rigorosa. Le parole sono implementa interfaccia, let, packages, private, protected, public. statica e resa
Per un elenco più completo, consulta la documentazione MDN qui: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode
|
Domanda molto attiva. Guadagna 10 punti reputazione per rispondere a questa domanda. Il requisito di reputazione aiuta a proteggere questa domanda dallo spam e dalle attività di mancata risposta.
Non è la risposta che stai cercando? Sfoglia altre domande contrassegnate con la sintassi javascript jslint use-strict o fai la tua domanda.